package com.example.utils.util.LockSupportTest;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * TODO  创建一个可定期或者延时执行任务的定长线程池，支持定时及周期性任务执行
 *      Executors.newScheduledThreadPool(3):
 *      public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
 *          return new ScheduledThreadPoolExecutor(corePoolSize);
 *      }
 *      public ScheduledThreadPoolExecutor(int corePoolSize) {
 *         super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
 *                new DelayedWorkQueue());
 *      }
 *      (1). newCachedThreadPool
 *      创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
 *      线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。
 *      (2). newFixedThreadPool
 *      创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
 *      定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()。
 *      (3) newScheduledThreadPool
 *      创建一个定长线程池，支持定时及周期性任务执行。延迟执行.(本文测试使用)
 *      ScheduledExecutorService比Timer更安全，功能更强大
 *      (4)、newSingleThreadExecutor
 *      创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
 *
 * @ClassName ScheduledThreadPoolTest
 * @Author xiaojiang
 * @Date 2021/10/13 上午 10:46
 */
public class ScheduledThreadPoolTest {

    private ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(50);

    public void sendRelease() {
        scheduledThreadPool.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("-=-=-=-=-=");
            }
        }, 500, TimeUnit.MILLISECONDS);
    }

//-----------------------------------------------------------------------------------------------------
    
    private ExecutorService InterRegTwoScheduledThreadPool = Executors.newFixedThreadPool(50);

    public void InterRegTwoThread(String data) {
        InterRegTwoScheduledThreadPool.submit(new Runnable() {
            @Override
            public void run() {
                String imsi = data.substring(0, data.indexOf("/"));
                String random = data.substring(data.indexOf("/") + 1, data.indexOf("+"));
                System.out.println("random = " + random);
                String type = data.substring(data.indexOf("+") + 1, data.length());
                System.out.println("type = " + type);
//                InterRegTwo(imsi, type, random);
            }
        });
    }

    public static void main(String[] args) throws InterruptedException {
        final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");

        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);

        System.out.println("提交时间: " + sdf.format(new Date()));

        //延迟3秒钟后执行任务
        scheduledThreadPool.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("运行时间: " + sdf.format(new Date()));
            }
        }, 3, TimeUnit.SECONDS);

        //延迟1秒钟后每隔3秒执行一次任务
//        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println("运行时间: " + sdf.format(new Date()));
//            }
//        }, 1, 3, TimeUnit.SECONDS);
        Thread.sleep(10000);

        scheduledThreadPool.shutdown();
    }

}
